home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / pm-utils / pm-functions < prev   
Encoding:
Text File  |  2009-10-06  |  7.8 KB  |  300 lines
  1. #!/bin/sh
  2. # vim:noexpandtab
  3.  
  4.  
  5. # Default values go here.  It is important to _not_ initialize some
  6. # variables here.  They are:
  7. #
  8. # PM_CMDLINE
  9. # RESUME_MODULES
  10. #
  11. # for great debugging!
  12. [ "${PM_DEBUG}" = "true" ] && {
  13.     export PM_DEBUG
  14.     set -x
  15. }
  16. set -a
  17. PM_UTILS_LIBDIR="/usr/lib/pm-utils"
  18. PM_UTILS_ETCDIR="/etc/pm"
  19. PM_UTILS_RUNDIR="/var/run/pm-utils"
  20.  
  21. PATH=/sbin:/usr/sbin:/bin:/usr/bin:"${PM_UTILS_LIBDIR}"/bin
  22. PM_LOGFILE="/var/log/${STASHNAME}.log"
  23. TEMPORARY_CPUFREQ_GOVERNOR="performance"
  24. LOCKDIR="${PM_UTILS_RUNDIR}/locks"
  25. STORAGEDIR="${PM_UTILS_RUNDIR}/${STASHNAME}/storage"
  26. NA=254
  27. NX=253
  28. DX=252
  29. PM_FUNCTIONS="$PM_UTILS_LIBDIR/functions"
  30. # Use c sort order
  31. LC_COLLATE=C
  32.  
  33. # These should be overridden by defaults and/or config.d settings.
  34. # Specifically, distros should override these by modifying defaults,
  35. # and end users should modify these using files in /etc/pm/config.
  36. HIBERNATE_MODE=""
  37. HIBERNATE_RESUME_POST_VIDEO="no"
  38. SLEEP_MODULE="kernel"
  39. # These variables will be handled specially when we load the config file.
  40. SUSPEND_MODULES=""
  41. HOOK_BLACKLIST=""
  42. ADD_PARAMETERS=""
  43. DROP_PARAMETERS=""
  44. PARAMETERS="${STORAGEDIR}/parameters"
  45. INHIBIT="${STORAGEDIR}/inhibit"
  46. PM_CMDLINE="$*"
  47. BEFORE_HOOKS=""
  48. MODULE_HELP=""
  49. SUSPEND_MODULE=""
  50. HIBERNATE_MODULE=""
  51. SUSPEND_HYBRID_MODULE=""
  52.  
  53. # when loading configuration files, allow stash-specific ones
  54. # to override the pm-utils global ones.
  55. [ -f "${PM_UTILS_LIBDIR}"/defaults ] && . "${PM_UTILS_LIBDIR}"/defaults
  56. [ -f "${PM_UTILS_LIBDIR}/${STASHNAME}.defaults" ] && \
  57.     . "${PM_UTILS_LIBDIR}/${STASHNAME}.defaults"
  58. set +a
  59.  
  60. for cfg in "${PM_UTILS_ETCDIR}"/config.d/*[!~] \
  61.            "${PM_UTILS_ETCDIR}/${STASHNAME}.config.d"/*[!~]; do
  62.     [ -f "$cfg" ] || continue
  63.     # Ugly, I know. The goal here is to allow multiple files in
  64.     # /etc/pm/config.d declare these variables and have those 
  65.     # declarations add together instead of the last one overwriting
  66.     # all the others.
  67.     [ "$SUSPEND_MODULES" ] && REAL_SUSPEND_MODULES="$SUSPEND_MODULES"
  68.     [ "$HOOK_BLACKLIST" ] && REAL_HOOK_BLACKLIST="$HOOK_BLACKLIST"
  69.     [ "$ADD_PARAMETERS" ] && REAL_ADD_PARAMETERS="$ADD_PARAMETERS"
  70.     [ "$DROP_PARAMETERS" ] && REAL_DROP_PARAMETERS="$DROP_PARAMETERS"
  71.     set -a
  72.     . "${cfg}"
  73.     SUSPEND_MODULES="$REAL_SUSPEND_MODULES $SUSPEND_MODULES"
  74.     HOOK_BLACKLIST="$REAL_HOOK_BLACKLIST $HOOK_BLACKLIST"
  75.     ADD_PARAMETERS="$REAL_ADD_PARAMETERS $ADD_PARAMETERS"
  76.     DROP_PARAMETERS="$REAL_DROP_PARAMETERS $DROP_PARAMETERS"
  77.     set +a
  78. done
  79.  
  80. . "${PM_FUNCTIONS}"
  81.  
  82. if command_exists hal-get-property; then
  83.     export CHASSIS_TYPE="$(hal-get-property --udi /org/freedesktop/Hal/devices/computer --key system.chassis.type 2>/dev/null || echo Unknown)"
  84. else
  85.     export CHASSIS_TYPE=Unknown
  86. fi
  87.  
  88. # Simple little logging function.
  89. # We do it this way because 'echo -n' is not posix.
  90. log()
  91. {
  92.     [ $LOGGING ] || return 0;
  93.     local fmt='%s\n'
  94.     [ "$1" = "-n" ] && { fmt='%s'; shift; }
  95.     printf "$fmt" "$*"
  96. }
  97.  
  98. add_before_hooks() {
  99.     [ -z "$BEFORE_HOOKS" ] && BEFORE_HOOKS="$*" || \
  100.         BEFORE_HOOKS="$BEFORE_HOOKS $*"
  101. }
  102.  
  103. add_module_help() {
  104.     [ -z "$MODULE_HELP" ] && MODULE_HELP="$*" || \
  105.         MODULE_HELP="$MODULE_HELP $*"
  106. }
  107.  
  108. before_hooks()
  109. {
  110.     [ -z "$BEFORE_HOOKS" ] && return 0
  111.     local meth
  112.     for meth in $BEFORE_HOOKS; do
  113.         command_exists "$meth" && "$meth"
  114.     done
  115. }
  116.  
  117. sleep_module_help()
  118. {
  119.     [ -z "$MODULE_HELP" ] && return 0
  120.     local meth
  121.     for meth in $MODULE_HELP; do
  122.         command_exists "$meth" && "$meth"
  123.     done
  124. }
  125.  
  126. # update PM_CMDLINE iff someone changed our parameters
  127. update_parameters()
  128. {
  129.     [ -f "$PARAMETERS.new" ] || return
  130.     export PM_CMDLINE="$(get_parameters)"
  131.     rm -f "$PARAMETERS.new"
  132. }
  133.  
  134. # if the user asked us to blacklist any hooks, do it.
  135. load_hook_blacklist()
  136. {
  137.     [ "$HOOK_BLACKLIST" ] || return
  138.     local hook
  139.     for hook in $HOOK_BLACKLIST; do
  140.         disablehook "${hook}" "blacklisted by user"
  141.         log "Blacklisting ${hook}."
  142.     done
  143. }
  144.  
  145. load_hook_parameters()
  146. {
  147.     [ "$DROP_PARAMETERS" ] && remove_parameters $DROP_PARAMETERS
  148.     [ "$ADD_PARAMETERS" ]  && add_parameters $ADD_PARAMETERS
  149.     update_parameters
  150. }
  151.  
  152.  
  153. hook_exit_status(){
  154.     case $1 in
  155.         0)   log "success." ;;
  156.         $NA) log "not applicable." ;;
  157.         $NX) log "not executable." ;;
  158.         $DX) log "disabled." ;;
  159.         *)   log "Returned exit code $1."; return 1 ;;
  160.     esac
  161. }
  162.  
  163. # check to see if a hook is a candidate for being run.
  164. hook_ok()
  165. {
  166.     local hook="${1##*/}"
  167.     # the actual name as passed to us.
  168.     [ -f "$STORAGEDIR/disable_hook:$hook" ] && return $DX
  169.     # name with leading digits chopped off the filename
  170.     [ -f "$STORAGEDIR/disable_hook:${hook#[0-9][0-9]}" ] && return $DX
  171.     [ -x "$1" ] || return $NX
  172.     return 0
  173. }
  174.  
  175. # Run all applicable hooks, logging success and failure as we go.
  176. run_hooks() {
  177.     # $1 = type of hook to find.  
  178.     # $2 = paramaters to pass to hooks.
  179.     # $3 = if present and equal to "reverse", run hooks backwards.
  180.     # Currently only power and sleep are meaningful.
  181.     local syshooks="${PM_UTILS_ETCDIR}/$1.d"
  182.     local phooks="${PM_UTILS_LIBDIR}/$1.d"
  183.     command_exists before_hooks && before_hooks
  184.     local sort="sort"
  185.     local base
  186.     local hook
  187.     local oifs="${IFS}"
  188.     # the next two lines are not a typo or a formatting error!
  189.     local nifs="
  190. "
  191.     IFS="${nifs}" # tolerate spaces in filenames.
  192.     [ "$3" = "reverse" ] && sort="sort -r"
  193.     for base in $(IFS="${oifs}"; for f in "$syshooks/"*[!~] "$phooks/"*[!~];
  194.         do [ -O "$f" ] && echo ${f##*/} ; done | $sort | uniq) ;
  195.     do
  196.         IFS="${oifs}"
  197.         # if we are running backwards, skip hooks that we did not 
  198.         # run going forwards due to a hook failing.
  199.         [ "$3" -a "$3" = "reverse" -a "$LAST_HOOK" ] && \
  200.             [ "$base" \> "$LAST_HOOK" ] && continue
  201.         # if we have already inhibited suspend/resume,
  202.         # don't run any more hooks.
  203.         [ ! "$3" ] && inhibited && break
  204.         update_parameters
  205.         if [ -f "$syshooks/$base" ]; then
  206.             hook="$syshooks/$base"
  207.         elif [ -f "$phooks/$base" ]; then
  208.             hook="$phooks/$base"
  209.         fi
  210.         log -n "${hook} $2: "
  211.         hook_ok "$hook" && "${hook}" $2 
  212.         # if the hook exited with an unknown exit code inhibit,
  213.         # otherwise record this as the last hook that ran.
  214.         hook_exit_status $? && LAST_HOOK="$base" || inhibit
  215.         IFS="${nifs}"
  216.     done
  217.     IFS="${oifs}"
  218.     # return value is 1 if something was inhibited, 0 otherwise.
  219.     inhibited && return 1 || return 0
  220. }
  221.  
  222. # Try to reinitalize the logfile. Fail unless certian criteria are met.
  223. init_logfile()
  224. {
  225.     if [ -z "$1" ]; then
  226.         echo "Please pass a filename to init_logfile."
  227.         return 1    
  228.     elif [ -h "$1" ]; then
  229.         echo "$1 is a symbolic link, refusing to overwrite."
  230.         return 1
  231.     elif [ -f "$1" -a ! -O "$1"  ]; then
  232.         echo "We do not own $1, refusing to overwrite."
  233.         return 1
  234.     fi
  235.     export LOGGING=true
  236.     exec >> "$1" 2>&1
  237. }
  238.  
  239. check_suspend() { [ -n "$SUSPEND_MODULE" ]; }
  240. check_hibernate() { [ -n "$HIBERNATE_MODULE" ]; }
  241. check_suspend_hybrid() { [ -n "$SUSPEND_HYBRID_MODULE" ]; }
  242.  
  243.  
  244. check_suspend_pmu()
  245. {
  246.     perl << EOF
  247. sub PMU_IOC_CAN_SLEEP { 0x40044205; }
  248. open PMU, '/dev/pmu' or die "open /dev/pmu: \$!";
  249. \$p = pack 'l', 0;
  250. ioctl PMU, &PMU_IOC_CAN_SLEEP, \$p or die "ioctl: \$!";
  251. (\$v) = unpack 'l', \$p;
  252. exit (\$v ? 0 : 1);
  253. EOF
  254. }
  255.  
  256. do_suspend_pmu()
  257. {
  258.     perl << EOF
  259. sub PMU_IOC_SLEEP { 0x20004200; }
  260. open PMU, "/dev/pmu" or die "open /dev/pmu: \$!";
  261. ioctl PMU, &PMU_IOC_SLEEP, 0;
  262. EOF
  263. }
  264.  
  265. # allow autodetection of sleep methods
  266. if [ "$SLEEP_MODULE" = "auto" ]; then
  267.     SLEEP_MODULE="tuxonice uswsusp"
  268. fi
  269.  
  270. for mod in $SLEEP_MODULE; do
  271.     mod="${PM_UTILS_LIBDIR}/module.d/${mod}"
  272.     [ -f "$mod" ] || continue
  273.     . "$mod"
  274. done
  275.  
  276. # always fall back to kernel methods if nothing else was declared
  277.  
  278. if [ -z "$SUSPEND_MODULE" ]; then
  279.     if grep -q mem /sys/power/state; then
  280.         SUSPEND_MODULE="kernel"
  281.         do_suspend() { echo -n "mem" >/sys/power/state; }
  282.     elif [ -c /dev/pmu ] && check_suspend_pmu; then
  283.         SUSPEND_MODULE="kernel"
  284.         do_suspend() { do_suspend_pmu; }
  285.     fi
  286. fi
  287.  
  288. if [ -z "$HIBERNATE_MODULE" ] && \
  289.     [ -f /sys/power/disk ] && \
  290.     grep -q disk /sys/power/state; then
  291.     HIBERNATE_MODULE="kernel"
  292.     do_hibernate()
  293.     {
  294.         [ -n "${HIBERNATE_MODE}" ] && \
  295.         grep -qw "${HIBERNATE_MODE}" /sys/power/disk && \
  296.         echo -n "${HIBERNATE_MODE}" > /sys/power/disk
  297.         echo -n "disk" > /sys/power/state
  298.     }
  299. fi
  300.